home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Snippets / Select Multiple Files 0.98 / Select Multiple Files.c < prev    next >
Encoding:
Text File  |  1994-12-01  |  31.2 KB  |  843 lines  |  [TEXT/KAHL]
  1. o support
  2. // this feature. I worked on this every night for over a week trying to get things to work
  3. // the way I wanted them to for an application I'm writing. After I got it working, I saw
  4. // several requests in comp.sys.mac.programmer for this type of functionality, so I put
  5. // together this demo app. My application did NOT require all the features I demonstrate
  6. // here -- my application uses files in the order the user clicked them, not alphabetical
  7. // order like shown here (alpha order is better for most apps, though) and my app allows
  8. // the user to select a particular file as many times as they'd like, not once like shown
  9. // here (I didn't need the "file filter" code, but provided one in the demo since others will).
  10. // Since removing features is easier than adding them, I added those features in hope that
  11. // they would prove useful to someone.
  12. //
  13. // That said, let me say that there are probably still bugs in this code, and that this is only
  14. // meant to be a "starting point" for you! Neither Hewlett-Packard nor myself are responsible
  15. // for anything that happens from the use of this code. That is, #include <std/disclaimer.h>
  16. //
  17. // Very special thanks to Ari Halberstadt, for his "WinterShell", which got me started
  18. // down the right path for this endeavour, and to Scott Knaster / Keith Rollin, authors of
  19. // "Macintosh Programming Secrets" for lots of insight when I was learning to program
  20. // the Mac. Extra special thanks to Lloyd Lim of Lim Unlimited for allowing me to use his
  21. // wonderful method of drawing gray outlines. The original source for this material was
  22. // his "Default" CDEF, version 2.4.
  23. //
  24. // If you use this code, or any code derived from it, in your application, you should include
  25. // my name in your "About" box and/or documentation. I'd like to hear about it via e-mail
  26. // as well. And if you want to give me a registered copy, that would be fine with me, too!
  27. // Other than that, there are no restrictions on the use or distribution of this code, as
  28. // long as this notice, my name and copyright remains intact when redistributing it.
  29. //
  30. // Oh yeah, if you do find any bugs, you improve the code, find this useful, or have any
  31. // suggestions, want to give me money, etc., please let me know!
  32. //
  33. // Eddy J. Gurney <egurney@vcd.hp.com>
  34. // v0.97 April 26, 1994 (My initial working version of this demo. Never released.)
  35. // v0.98 November 30, 1994 (Cleaned up code for release on the Apprentice CD-ROM.)
  36. //
  37. // To do:
  38. //   * Add support for keyboard in "selected files" list
  39. //   * Clean up Balloon Help
  40. //
  41. // PS: I write code in Geneva 9 with tabs every 4 spaces, so you may have to adjust
  42. // your editor to view this like I do. :-)
  43.  
  44. #include "Select Multiple Files.h"
  45. #include "ArrayListLib.h"
  46. #include <GestaltEqu.h>    /* For Gestalt constants */
  47. #include <Packages.h>    /* For IUMagString */
  48. #include <Palettes.h>    /* For GetGray() */
  49.  
  50. /* Local types */
  51. typedef struct {
  52.     StandardFileReply    *theReply;    /* the reply record */
  53.     ListHandle            selectedList;    /* handle to the select file list */
  54.     ArrayListHandle    files;        /* list of selected files */
  55.     short            numTypes;
  56.     SFTypeList        typeList;
  57.     Boolean            active;        /* true if our file selection list is active */
  58.     Boolean            findNextFile;
  59.     short            nextCharacter;
  60.     short            extraEvent;
  61. } SFMultipleFileData;
  62.  
  63. /* For FrameItemInGray() */
  64. typedef struct {
  65.     PenState        penState;
  66.     RGBColor        backColor;
  67.     RGBColor        frameColor;
  68.     Rect            bounds;
  69.     Boolean        inactive;
  70.     Boolean        roundFrame;
  71.     Boolean        erasingOld;
  72. } GrayFrameData, *GrayFrameDataPtr;
  73.  
  74. /* Function prototypes */
  75. static pascal Boolean SFMultipleFileModalFilter(DialogPtr, EventRecord *, short *, void *);
  76. static pascal short SFMultipleFileDialogHook(short, DialogPtr, void *);
  77. static void DeselectListItems(ListHandle);
  78. void AddFileToList(DialogPtr, SFMultipleFileData *, FSSpec *, Boolean);
  79. pascal short ListMgrCompString(Ptr, Ptr, short, short);
  80. Point InsertInOrder(StringPtr, ListHandle);
  81. Boolean IsValidFileType(short, SFTypeList, OSType);
  82. Boolean FileAlreadyAdded(short, long, StringPtr, SFMultipleFileData *);
  83. static pascal void SFMultipleFileActivate(DialogPtr, short, Boolean, void *);
  84. static pascal Boolean SFMultipleFileFilter(ParamBlockRec *, void *);
  85. void ToolBoxInit(void);
  86. void FlashDialogItem(DialogPtr, short);
  87. void GetDItemRect(DialogPtr, short, Rect *);
  88. void HiliteDialogItem(DialogPtr, short, short);
  89. void MySetDialogDefaultItem(DialogPtr, short, Boolean);
  90. pascal void FrameItemInGray(WindowPtr, short);
  91. static pascal void GrayFrameDrawingProc(short, short, GDHandle, GrayFrameDataPtr);
  92. void SetGrayFrameDialogItem(DialogPtr, short);
  93. void SetDItemTitle(DialogPtr, short, StringPtr);
  94.  
  95. /* Global variables */
  96. long                gQuickDrawVersion;
  97.  
  98. main()
  99. {
  100.     long                gestaltResult;
  101.     StandardFileReply    theSFReply;
  102.     Point                where = { -1, -1 };
  103.     short            sendFileRefNum;
  104.     short            activeInputItemsList[] = { 2, sfItemFileListUser, dSFMultipleSelectedFilesList };
  105.     SFMultipleFileData    fileData;
  106.     OSErr            result;
  107.  
  108.     ToolBoxInit();
  109.     
  110.     if (Gestalt(gestaltQuickdrawVersion, &gQuickDrawVersion) != noErr)
  111.         ErrorHandler("\pGestalt error!");
  112.     if (Gestalt(gestaltStandardFileAttr, &gestaltResult) != noErr)
  113.         ErrorHandler("\pGestalt error!");
  114.     if (!(gestaltResult & (1 << gestaltStandardFile58)))
  115.         ErrorHandler("\pThe new Standard File routines are missing! Upgrade your system software!");
  116.  
  117.     /* Initialize the multiple file data structure before we use it */
  118.     fileData.theReply = &theSFReply;
  119.     fileData.selectedList = nil;
  120.     fileData.files = ArrayListBegin(sizeof(FSSpec)); /* Start our list of FSSpec's */
  121.     fileData.numTypes = 1;
  122.     fileData.typeList[0] = 'TEXT';
  123.     fileData.active = false;
  124.     fileData.findNextFile = false;
  125.     fileData.extraEvent = 0;
  126.  
  127.     /* Present the multiple file dialog */
  128.     CustomGetFile(SFMultipleFileFilter, fileData.numTypes, fileData.typeList, &theSFReply, 
  129.         rSFMultipleFileDialog, where, SFMultipleFileDialogHook, SFMultipleFileModalFilter,
  130.         activeInputItemsList, SFMultipleFileActivate, &fileData);
  131.  
  132.     if (theSFReply.sfGood) { /* The user clicked the "Open All" ("Open File") button */
  133.         long            totalSizeOfSelectedFiles;
  134.         FSSpec        fileSpec;
  135.         CInfoPBRec    pb;
  136.         DialogPtr        theDialog;
  137.         short        index, itemHit;
  138.         Str31        theNumber;
  139.  
  140.         /* Handle the case where the user clicked on the "Open File" button without adding any */
  141.         if (ArrayListCount(fileData.files) == 0) {
  142.             ArrayListInsert(fileData.files, 0);
  143.             ArrayListSet(fileData.files, 0, &theSFReply.sfFile);
  144.         }
  145.  
  146.         /* Now do something interesting with the selected files.
  147.             This shows how to access the files the user has selected. */
  148.  
  149.         /* Get the size of each file and add it to the total... */
  150.         totalSizeOfSelectedFiles = 0;
  151.         for (index = 0; index < ArrayListCount(fileData.files); index++) {
  152.             ArrayListGet(fileData.files, index, &fileSpec);
  153.             pb.hFileInfo.ioCompletion = nil;
  154.             pb.hFileInfo.ioNamePtr = fileSpec.name;
  155.             pb.hFileInfo.ioVRefNum = fileSpec.vRefNum;
  156.             pb.hFileInfo.ioFDirIndex = 0;
  157.             pb.hFileInfo.ioDirID = fileSpec.parID;
  158.             if (PBGetCatInfo(&pb, false) == noErr)
  159.                 totalSizeOfSelectedFiles += pb.hFileInfo.ioFlLgLen;
  160.             else
  161.                 break;
  162.         }        
  163.  
  164.         /* Present a simple dialog to the user */
  165.         NumToString((long)totalSizeOfSelectedFiles, theNumber);
  166.         ParamText(theNumber, nil, nil, nil);
  167.         theDialog = GetNewDialog(rTotalDialog, nil, (WindowPtr)-1);
  168.         ShowWindow(theDialog);
  169.         do {
  170.             ModalDialog(nil, &itemHit);
  171.         } while (!itemHit);
  172.         DisposeDialog(theDialog);
  173.     }
  174.  
  175.     ArrayListEnd(fileData.files); /* Dispose of the memory we used for the list of files */
  176. }
  177.  
  178. /******************************************************************/
  179.  
  180. /* Handle the dialog events */
  181. static pascal Boolean SFMultipleFileModalFilter(DialogPtr theDialog, EventRecord *theEvent, short *itemHit, void *myDataPtr)
  182. {
  183.     GrafPtr            savePort;
  184.     short            iType;
  185.     Handle            iHandle;
  186.     Rect                iRect;
  187.     SFMultipleFileData    *fileData = myDataPtr;
  188.     Boolean            result = false;
  189.  
  190.     GetPort(&savePort);
  191.  
  192.     switch (theEvent->what) {
  193.         case updateEvt: {
  194.             PenState    savePen;
  195.  
  196.             if (/* IsAppWindow((WindowPtr)theEvent->message) */ 0) {
  197.                 /* IsAppWindow is a function you provide that returns true if the passed WindowPtr
  198.                    belongs to your application. If it does, then you need to call your application's update
  199.                    function to redraw any windows which have Balloon Help holes in them, etc. */
  200.                 /* ProcessUpdateEvent((WindowPtr)theEvent->message); */
  201.              } else {
  202.                 /* It wasn't one of our application windows, so it must be our dialog */
  203.                 SetPort(theDialog);
  204.                 GetPenState(&savePen);
  205.                 PenNormal();
  206.                 LUpdate(theDialog->visRgn, fileData->selectedList);
  207.                 GetDItem(theDialog, dSFMultipleSelectedFilesList, &iType, &iHandle, &iRect);
  208.                 FrameRect(&iRect);
  209.                 if (fileData->active) {
  210.                     InsetRect(&iRect, -3, -3);
  211.                     PenSize(2, 2);
  212.                     FrameRect(&iRect);
  213.                 }
  214.                 SetPenState(&savePen);
  215.             }
  216.             break;
  217.         }
  218.         case activateEvt:
  219.             if (/* IsAppWindow((WindowPtr)theEvent->message) */ 0) {
  220.                 /* IsAppWindow is a function you provide that returns true if the passed WindowPtr
  221.                    belongs to your application. If it does, then you need to call your application's activate
  222.                    function to activate/deactivate the specified window, etc. */
  223.                 /* ProcessActivateEvent((WindowPtr)theEvent->message, theEvent->modifiers & activeFlag); */
  224.             } else {
  225.                 /* It wasn't one of our application windows, so it must be our dialog */
  226.                 SetPort(theDialog);
  227.                 SFMultipleFileActivate(theDialog, dSFMultipleSelectedFilesList, 
  228.                     fileData->active && (theEvent->modifiers & activeFlag) != 0, fileData);
  229.                 LActivate((theEvent->modifiers & activeFlag) != 0, fileData->selectedList);
  230.             }
  231.             break;
  232.         case mouseDown:
  233.             if (GetWRefCon(theDialog) == sfMainDialogRefCon) {
  234.                 Point        where = theEvent->where;
  235.  
  236.                 SetPort(theDialog);                
  237.                 GlobalToLocal(&where);
  238.  
  239.                 GetDItemRect(theDialog, dSFMultipleSelectedFilesList, &iRect);
  240.                 if (PtInRect(where, &iRect)) {
  241.                     /* A double click in the "selected files" list is the same as clicking "Remove"... */
  242.                     if (LClick(where, theEvent->modifiers, fileData->selectedList)) {
  243.                         *itemHit = dSFMultipleRemoveButton;
  244.                         FlashDialogItem(theDialog, *itemHit);
  245.                         result = true;
  246.                     }
  247.                 }
  248.             }
  249.             break;
  250.         case keyDown:
  251.         case autoKey:
  252.             if (GetWRefCon(theDialog) == sfMainDialogRefCon) {
  253.                 char        key = theEvent->message;
  254.                 
  255.                 SetPort(theDialog);
  256.                 if ((theEvent->modifiers & cmdKey) != 0) {
  257.                     switch (key) {
  258.                         /* Handle any dialog Command-key equivalents for the dialog here, 
  259.                            like Cmd-A for Add All, or something? */ 
  260.                     }
  261.                 } else if (fileData->active && key != tabKey) {
  262.                     /* Ooops. This isn't quite done yet! You need to handle the up/down keys
  263.                     here, add the ability for the user to type the first few characters of an
  264.                     entry and jump to it, etc. See Ari's "WinterShell" if you need help! */
  265.                 }
  266.             }
  267.             break;
  268.     }
  269.     
  270.     SetPort(savePort);
  271.     return result;
  272. }
  273.  
  274. static pascal short SFMultipleFileDialogHook(short item, DialogPtr theDialog, void *myDataPtr)
  275. {
  276.     GrafPtr            savePort;
  277.     SFMultipleFileData    *fileData = myDataPtr;
  278.     Cell                cell;                    /* for accessing cells in list */
  279.     short            index;                /* index for inserting/removing from list */
  280.     
  281.     GetPort(&savePort);
  282.     SetPort(theDialog);
  283.     
  284.     if (GetWRefCon(theDialog) == sfMainDialogRefCon) {
  285.         Boolean    isFile = !fileData->theReply->sfIsVolume && !fileData->theReply->sfIsFolder && *fileData->theReply->sfFile.name;
  286.  
  287.         /* Select the next file in the list for the user OR adjust the dialog buttons. */
  288.         if (fileData->selectedList) {
  289.             /* Ok, this is a real wizzy feature. When you add a file, it is removed from the "top" list
  290.               of files, and the hilite for that list just "disappears". That means the user has to manually
  291.               select the next file to add. (If you really want to see what I'm talking about, just comment
  292.               out the whole if statement below and click the "Add" button.) Since this code hilites the last file
  293.               added in the "bottom" list, we can get its name... and simulate the user typing in each character
  294.               of the name! This means the hilite moves to the file (or directory) AFTER the file the user just
  295.               added. Cool, huh? It IS a little sluggish right now, probably because of the two List Manager
  296.               calls. It would be faster to keep a copy of the filename we just added in the fileData structure,
  297.               but this was a quick-and-dirty last minute hack, so I'll leave performance optimizations as an
  298.               exercise for the programmer. :-) */
  299.             if (fileData->findNextFile && !fileData->active) {
  300.                 Str63    fileName;
  301.                 short    length = sizeof(fileName);
  302.                 
  303.                 cell.h = cell.v = 0;
  304.                 if (LGetSelect(true, &cell, fileData->selectedList)) {
  305.                     LGetCell(fileName, &length, cell, fileData->selectedList);
  306.                     if (fileData->nextCharacter < length) {
  307.                         item = sfHookCharOffset + *(fileName + fileData->nextCharacter);
  308.                         fileData->nextCharacter++;
  309.                         return item;
  310.                     }
  311.                     fileData->findNextFile = false;
  312.                 }
  313.             }
  314.  
  315.             /* See the comments at the end of the "Remove" button code for why we have this */
  316.             if (fileData->extraEvent) {
  317.                 item = fileData->extraEvent;
  318.                 fileData->extraEvent = 0;
  319.                 return item;
  320.             }
  321.             
  322.             cell.h = cell.v = 0;
  323.             /* If a file in the "selected" list is selected, enable the Remove button */
  324.             HiliteDialogItem(theDialog, dSFMultipleRemoveButton, LGetSelect(true, &cell, fileData->selectedList) ? kControlActive : kControlInactive);
  325.             /* If the focus is in the list of files, enable the Add All button */
  326.             HiliteDialogItem(theDialog, dSFMultipleAddAllButton, !fileData->active ? kControlActive : kControlInactive);
  327.             /* Enable our "Open" button if a file is selected, or if files have been added */
  328.             if ((ArrayListCount(fileData->files) > 0) || (!fileData->active && isFile))
  329.                 HiliteDialogItem(theDialog, dSFMultipleOpenButton, kControlActive);
  330.             else
  331.                 HiliteDialogItem(theDialog, dSFMultipleOpenButton, kControlInactive); 
  332.             /* Change the default button depending on where the input focus is */
  333.             if (fileData->active) {
  334.                 if (ArrayListCount(fileData->files) == 0) {
  335.                     MySetDialogDefaultItem(theDialog, sfItemCancelButton, false);
  336.                 } else {
  337.                     MySetDialogDefaultItem(theDialog, dSFMultipleOpenButton, false);
  338.                 }
  339.             } else {
  340.                 if (*fileData->theReply->sfFile.name) {
  341.                     MySetDialogDefaultItem(theDialog, sfItemOpenButton, true);
  342.                 } else {
  343.                     MySetDialogDefaultItem(theDialog, sfItemCancelButton, false);
  344.                 }
  345.             }            
  346.         }
  347.         switch (item) {
  348.             case sfHookFirstCall:
  349.             {
  350.                 Rect        iRect;
  351.                 Rect        rDataBounds = { 0, 0, 0, 1 };    /* Data bounds of list */
  352.             
  353.                 /* Create the list */
  354.                 cell.h = cell.v = 0;
  355.                 GetDItemRect(theDialog, dSFMultipleSelectedFilesList, &iRect);
  356.                 InsetRect(&iRect, -kListInset, -kListInset);
  357.                 iRect.right -= kScrollBarAdjust;
  358.                 fileData->selectedList = LNew(&iRect, &rDataBounds, cell, 0, theDialog, true, false, false, true);
  359.                 if (fileData->selectedList == nil)
  360.                     ErrorHandler("\pCouldn't create the selected file list!!");
  361.                 SetGrayFrameDialogItem(theDialog, dSFMultipleLine1);
  362.                 SetGrayFrameDialogItem(theDialog, dSFMultipleLine2);
  363.                 MySetDialogDefaultItem(theDialog, sfItemOpenButton, false);
  364.                 break;
  365.             }
  366.             case sfHookLastCall:
  367.                 /* Dispose of the list */
  368.                 LDispose(fileData->selectedList);
  369.                 fileData->selectedList = nil;
  370.                 break;
  371.             case sfItemOpenButton:
  372.                 /* Add file to list */
  373.                 if (*fileData->theReply->sfFile.name && !fileData->active && isFile) {
  374.                     AddFileToList(theDialog, fileData, &fileData->theReply->sfFile, true);
  375.                     fileData->findNextFile = true;
  376.                     fileData->nextCharacter = 0;
  377.                     item = sfHookRebuildList;
  378.                 }
  379.                 break;
  380.             case dSFMultipleOpenButton:
  381.                 if (isFile || (ArrayListCount(fileData->files) > 0))
  382.                     /* Fake the system into thinking we selected the file by clicking on its "Open" button */
  383.                     item = sfItemOpenButton;
  384.                 else
  385.                     item = 0;
  386.                 break;
  387.             case dSFMultipleRemoveButton:
  388.                 cell.h = cell.v = 0;
  389.                 /* There can be more than one item selected in the "bottom" list, so remove all of 'em */
  390.                 while (LGetSelect(true, &cell, fileData->selectedList)) {
  391.                     index = cell.v;
  392.                     LDelRow(1, index, fileData->selectedList);
  393.                     ArrayListDelete(fileData->files, index);
  394.                     cell.h = cell.v = 0;
  395.                 }
  396.                 /* If there is only 1 item in the list, change the "Open List" button back to "Open File" */ 
  397.                 if (ArrayListCount(fileData->files) == 0) {
  398.                     Str31    openString;
  399.                     
  400.                     GetIndString(openString, rChangingButtonStrings, kOpenFileButton);
  401.                     SetDItemTitle(theDialog, dSFMultipleOpenButton, openString);
  402.                 }
  403.                 /* We want to be "cool"... so clicking on the remove button will select the "selected files"
  404.                    (bottom) list, unless we're removing the last item, in which case we automatically switch
  405.                    the input focus to the "file" list. We can only return one "item" (rebuildList in this case) so
  406.                    we handle it "special"... */
  407.                 if (ArrayListCount(fileData->files) == 0) {
  408.                     /* If there are no items left in the list, switch the focus back to the file list */
  409.                     fileData->extraEvent = sfHookSetActiveOffset + sfItemFileListUser;
  410.                 } else {
  411.                     fileData->extraEvent = sfHookSetActiveOffset + dSFMultipleSelectedFilesList;
  412.                 }
  413.                 item = sfHookRebuildList;
  414.                 break;
  415.             case dSFMultipleAddAllButton:
  416.             {
  417.                 FSSpec        fsSpec;
  418.                 CInfoPBRec    pb;
  419.                 Str63        name;
  420.                 Boolean        alreadyDeselected = false;
  421.                 
  422.                 LDoDraw(false, fileData->selectedList);    /* Turn off list updating while we add files */
  423.                 pb.hFileInfo.ioVRefNum = -SFSaveDisk;    /* The current directory SF is in */
  424.                 pb.hFileInfo.ioNamePtr = name;    /* Where the name of each entry will be placed */
  425.                 index = 1;
  426.                 do {
  427.                     pb.hFileInfo.ioDirID = CurDirStore;    /* You need to set this each time through the loop! */
  428.                     pb.hFileInfo.ioFDirIndex = index++;
  429.                     PBGetCatInfo(&pb, false);    /* Get file info */
  430.                     /* If successful GetCatInfo, the entry is a file, the file type is OK, and it hasn't been added, add it */
  431.                     if (pb.hFileInfo.ioResult == noErr && (pb.hFileInfo.ioFlAttrib & 0x10) == 0 &&
  432.                        IsValidFileType(fileData->numTypes, fileData->typeList, pb.hFileInfo.ioFlFndrInfo.fdType) &&
  433.                        !FileAlreadyAdded(pb.hFileInfo.ioVRefNum, pb.hFileInfo.ioFlParID, pb.hFileInfo.ioNamePtr, fileData)) {
  434.                            if (!alreadyDeselected) {
  435.                             DeselectListItems(fileData->selectedList);
  436.                             alreadyDeselected = true;
  437.                         }
  438.                         /* Create an FSSpec, since that is what we store for each added entry */
  439.                         fsSpec.vRefNum = pb.hFileInfo.ioVRefNum;
  440.                         fsSpec.parID = pb.hFileInfo.ioFlParID;
  441.                         BlockMove(pb.hFileInfo.ioNamePtr, fsSpec.name, *pb.hFileInfo.ioNamePtr + 1);
  442.                         AddFileToList(theDialog, fileData, &fsSpec, false);
  443.                     }
  444.                 } while (pb.hFileInfo.ioResult == noErr);
  445.                 LDoDraw(true, fileData->selectedList);    /* Turn drawing back on */
  446.                 LUpdate(theDialog->visRgn, fileData->selectedList);    /* And update the list */
  447.                 item = sfHookRebuildList;
  448.             }
  449.             break;
  450.         }
  451.     }
  452.     
  453.     SetPort(savePort);
  454.     return item;
  455. }
  456.  
  457. /* We deselect any items already selected before adding a new file */
  458. static void DeselectListItems(ListHandle theList)
  459. {
  460.     Cell        theCell = {0, 0};
  461.     
  462.     while (theCell.v < (*theList)->dataBounds.bottom) {
  463.         LSetSelect(false, theCell, theList);
  464.         theCell.v++;
  465.     }
  466. }
  467.  
  468. /* Add the information passed to the specified list */
  469. void AddFileToList(DialogPtr theDialog, SFMultipleFileData *fileData, FSSpec *theReply, Boolean doDeselect)
  470. {
  471.     Point        cell;
  472.     short    index;
  473.     
  474.     /* Insert name into the list */
  475.     cell = InsertInOrder(theReply->name, fileData->selectedList);
  476.     index = cell.v;
  477.     /* Insert into list of files, at index corresponding to item in display list, which makes it easy to
  478.        remove the item when the user hits Remove button */
  479.     ArrayListInsert(fileData->files, index);
  480.     ArrayListSet(fileData->files, index, theReply);
  481.     if (doDeselect)
  482.         /* Deselect any currently selected items... */
  483.         DeselectListItems(fileData->selectedList);
  484.     /* ...select the item we just added... */
  485.     LSetSelect(true, cell, fileData->selectedList);
  486.     /* ...and scroll it into view. */
  487.     LAutoScroll(fileData->selectedList);
  488.     /* If this is the first item we're adding to the list, change the "Open File" button to "Open List" */
  489.     if (index == 0) {
  490.         Str31    openString;
  491.         
  492.         GetIndString(openString, rChangingButtonStrings, kOpenListButton);
  493.         SetDItemTitle(theDialog, dSFMultipleOpenButton, openString);
  494.     }
  495. }
  496.  
  497. /* Compare string 'aPtr' and 'bPtr', and return 0 if the 'aPtr' string is
  498.    greater than the 'bPtr' string, otherwise return 1. */
  499. pascal short ListMgrCompString(Ptr aPtr, Ptr bPtr, short aLen, short bLen)
  500. {
  501.     if (IUMagString(aPtr, bPtr, aLen, bLen) == 1)
  502.         return 0;
  503.     else
  504.         return 1;
  505. }
  506.  
  507. /* Add the string 'stringToAdd' to the list 'theList', in alphabetical order
  508.    using the search procedure ListMgrCompString() */
  509. Point InsertInOrder(StringPtr stringToAdd, ListHandle theList)
  510. {
  511.     Point        cell = {0, 0};
  512.     
  513.     (void)LSearch((Ptr)stringToAdd + 1, (short)*stringToAdd, 
  514.         (SearchProcPtr)&ListMgrCompString, &cell, theList);
  515.     (void)LAddRow(1, cell.v, theList);
  516.     LSetCell(stringToAdd + 1, (short)*stringToAdd, cell, theList);
  517.     
  518.     return cell;
  519. }
  520.  
  521. /* Return 'true' if the specified file type is in the type list */
  522. Boolean IsValidFileType(short numTypes, SFTypeList typeList, OSType fileType)
  523. {
  524.     Boolean    isValid = false;
  525.     short    index;
  526.     
  527.     for (index = 0; !isValid && index < numTypes; index++)
  528.         isValid = fileType == typeList[index];
  529.         
  530.     return isValid;
  531. }
  532.  
  533. /* If the specified file parameters match a file in the list, return true since it has already been added */
  534. Boolean FileAlreadyAdded(short ioVRefNum, long ioFlParID, StringPtr namePtr, SFMultipleFileData *fileData)
  535. {
  536.     FSSpec            **files;
  537.     short            nfiles;
  538.     SignedByte        state;
  539.     Boolean            found;
  540.     short            i;
  541.  
  542.     found = false;
  543.     files = ArrayListGetHandle(fileData->files);
  544.     nfiles = ArrayListCount(fileData->files);
  545.     state = HGetState((Handle)files);
  546.     HLock((Handle)files);
  547.  
  548.     for (i = 0; !found && i < nfiles; i++) {
  549.         /* Check and see if a file is already in the list and return true if it is... */
  550.         found = (ioVRefNum == (*files)[i].vRefNum &&
  551.                 ioFlParID == (*files)[i].parID &&
  552.                 (EqualString(namePtr, (*files)[i].name, true, true) == true));
  553.     }
  554.  
  555.     HSetState((Handle)files, state);
  556.  
  557.     return found;
  558. }
  559.  
  560. /* Change the hiliting of the list to indicate that it is active and receiving keyboard input */
  561. static pascal void SFMultipleFileActivate(DialogPtr theDialog, short item, Boolean activating, void *myDataPtr)
  562. {
  563.     GrafPtr            savePort;
  564.     PenState            savePen;
  565.     SFMultipleFileData    *fileData = myDataPtr;
  566.     Cell                cell;
  567.     
  568.     GetPort(&savePort);
  569.     SetPort(theDialog);
  570.     GetPenState(&savePen);
  571.     
  572.     activating = (activating != 0);    /* uses 0xFF for true, so convert to Boolean */
  573.  
  574.     if (item == dSFMultipleSelectedFilesList) {
  575.         Rect        theRect;
  576.         
  577.         fileData->active = activating;
  578.         if (!activating)
  579.             PenPat(qd.white);
  580.         PenSize(2, 2);
  581.         GetDItemRect(theDialog, item, &theRect);
  582.         InsetRect(&theRect, -3, -3);
  583.         FrameRect(&theRect);
  584.     }
  585.  
  586.     SetPenState(&savePen);
  587.     SetPort(savePort);
  588. }
  589.  
  590. /* Filter files that have already been "added" */
  591. static pascal Boolean SFMultipleFileFilter(ParamBlockRec *pb, void *myDataPtr)
  592. {
  593.     CInfoPBRec    *cat = (CInfoPBRec *)pb;        /* this isn't documented but seems to work */
  594.     Boolean        hide;
  595.  
  596.     if ((pb->fileParam.ioFlAttrib & 0x10) == 0) {    /* param block describes a file */
  597.         hide = FileAlreadyAdded(cat->hFileInfo.ioVRefNum, cat->hFileInfo.ioFlParID, 
  598.                             cat->hFileInfo.ioNamePtr, myDataPtr);
  599.     } else {
  600.         hide = false;
  601.     }
  602.  
  603.     return hide;
  604. }
  605.  
  606. void ToolBoxInit()
  607. {
  608.     InitGraf(&qd.thePort);
  609.     InitFonts();
  610.     FlushEvents(everyEvent, 0);
  611.     InitWindows();
  612.     InitMenus();
  613.     TEInit();
  614.     InitDialogs(nil);
  615.     MaxApplZone();
  616.     InitCursor();
  617. }
  618.  
  619. /* Quickly flash a button in the dialog */
  620. void FlashDialogItem(DialogPtr theDialog, short theItem)
  621. {
  622.     short    iType;
  623.     Handle    iHandle;
  624.     Rect        iRect;
  625.     long        ignored;
  626.  
  627.     GetDItem(theDialog, theItem, &iType, &iHandle, &iRect);
  628.     HiliteControl((ControlHandle)iHandle, 1);
  629.     Delay(8, &ignored);
  630.     HiliteControl((ControlHandle)iHandle, 0);
  631. }
  632.  
  633. /* Return the enclosing rectangle of the specified dialog item, in coordinates
  634.    local to the specified dialog. */
  635. void GetDItemRect(DialogPtr theDialog, short theItem, Rect *iRect)
  636. {
  637.     Handle    iHandle;
  638.     short    iType;
  639.     
  640.     GetDItem(theDialog, theItem, &iType, &iHandle, iRect);
  641. }
  642.  
  643. /* Make a control active/inactive, or highlight/dim the specified part */
  644. void HiliteDialogItem(DialogPtr theDialog, short theItem, short code)
  645. {
  646.     short    iType; 
  647.     Handle    iHandle; 
  648.     Rect        iRect;
  649.  
  650.     GetDItem(theDialog, theItem, &iType, &iHandle, &iRect);
  651.     HiliteControl((ControlHandle)iHandle, code);
  652. }
  653.  
  654. /****************************************************
  655.     SetDialogItemTitle
  656.  
  657.     Change the text associated with a particular dialog item. This is a little
  658.     tricky since there are two ways to change the text. If you are dealing
  659.     with an EditText or StatText (static text) item, you must call SetIText.
  660.     If you are dealing with a dialog item that is backed up by a Control
  661.     Manager control (like a simple button, radio button, or checkbox), you
  662.     must call SetCTitle.
  663.  
  664.     We determine what kind of dialog item we are dealing with by calling
  665.     GetDItem. Returned in the “kind” parameter is a number that identifies
  666.     what sort of item we are handling. First, we strip off the upper bit,
  667.     which identifies the item as being enabled or disabled. Once that bit is
  668.     removed, we can examine the kind of the item and act accordingly.
  669.  
  670.     Notice the special handling we give to controls when we call SetCTitle.
  671.     This is to take care of “excessive flashing” as Online Companion puts it.
  672.     When you call SetCTitle, the control manager first calls HideControl to
  673.     remove the control with its old text from the screen. It then changes the
  674.     control’s title in the ControlRecord, and reshows the control by calling
  675.     ShowControl. At this point, the control is properly shown on the screen
  676.     with its correct, new title.
  677.  
  678.     However, there’s a little time bomb lurking in the works. When HideControl
  679.     was called, the Control Manager called InvalRect on the area the control
  680.     occupied. Even though ShowControl was later called on the same area and
  681.     everything is drawn correctly, that rectangle is still marked as invalid
  682.     and is incorporated into the update region for the dialog. The event loop
  683.     at the heart of ModalDialog will then get an update event for that area
  684.     and redraw the button _again_! This can cause the button to flicker and
  685.     flash more than we would like. We already know that that area is
  686.     adequately drawn, so we tell the Event Manager to hoof it by validating it
  687.     with a call to ValidRect.
  688. *****************************************************/
  689. void SetDItemTitle(DialogPtr theDialog, short theItem, StringPtr newTitle)
  690. {
  691.     short    iType;
  692.     Handle    iHandle;
  693.     Rect        iRect;
  694.  
  695.     GetDItem(theDialog, theItem, &iType, &iHandle, &iRect);
  696.     iType &= ~itemDisable;    /* Strip off the enable/disable bit */
  697.     if ((iType == statText) || (iType == editText)) {
  698.         SetIText(iHandle, newTitle);
  699.     } else {
  700.         SetCTitle((ControlHandle)iHandle, newTitle);
  701.         SetPort(theDialog);
  702.         ValidRect(&iRect);
  703.     }
  704. }
  705.  
  706. /****************************************************
  707.     SetGrayFrameDialogItem    Set the specified dialog item to have a special
  708.                         drawing procedure which will simply outline the
  709.                         item's rectangle in "gray". Dividing lines can be
  710.                         easily defined this way by setting the height or
  711.                         width of the user item to 1.
  712. *****************************************************/
  713. void SetGrayFrameDialogItem(DialogPtr theDialog, short theItem)
  714. {
  715.     Rect            iRect;
  716.     Handle        iHandle;
  717.     short        iType;
  718.  
  719.     GetDItem(theDialog, theItem, &iType, &iHandle, &iRect);
  720.     SetDItem(theDialog, theItem, iType, (ProcPtr)FrameItemInGray, &iRect);
  721. }
  722.  
  723. void MySetDialogDefaultItem(DialogPtr theDialog, short theItem, Boolean forceActive)
  724. {
  725.     if (((DialogPeek)theDialog)->aDefItem != theItem) {
  726.         GrafPtr        savePort;
  727.         GrayFrameData    frameData;
  728.     
  729.         GetPort(&savePort);
  730.         SetPort(theDialog);
  731.  
  732.         /* Erase the old default button */        
  733.         GetPenState(&frameData.penState);
  734.         GetDItemRect(theDialog, ((DialogPeek)theDialog)->aDefItem, &frameData.bounds);
  735.         InsetRect(&frameData.bounds, -4, -4);
  736.         frameData.roundFrame = true;
  737.         frameData.inactive = false;
  738.         frameData.erasingOld = true;
  739.         GrayFrameDrawingProc(0, 0, nil, &frameData);
  740.  
  741.         ((DialogPeek)theDialog)->aDefItem = theItem;
  742.         if (forceActive)
  743.             HiliteDialogItem(theDialog, theItem, kControlActive);
  744.         FrameItemInGray(theDialog, theItem);
  745.         
  746.         SetPort(savePort);
  747.     }
  748. }        
  749.  
  750. /*******************************************************
  751.     FrameItemInGray() and GrayFrameDrawingProc() are adapted routines based
  752.     primarily on Lloyd Lim’s wonderful method of drawing things in "gray" correctly
  753.     in his "Default" CDEF. He gave me permission to use them here, and for that I am
  754.     indebted! This is the best method I’ve seen for drawing things across multiple
  755.     monitors with different bit depths, etc. Very slick!
  756. *******************************************************/
  757. pascal void FrameItemInGray(WindowPtr theDialog, short theItem)
  758. {
  759.     short        iType;
  760.     ControlHandle    theControl;
  761.     GrayFrameData    frameData;
  762.     RGBColor        foreColor;
  763.     AuxCtlHandle    theAuxCtl;
  764.  
  765.     GetPenState(&frameData.penState);
  766.  
  767.     GetDItem(theDialog, theItem, &iType, (Handle *)&theControl, &frameData.bounds);
  768.     if ((iType & ~itemDisable) == (ctrlItem | btnCtrl)) {
  769.         frameData.roundFrame = true;
  770.         InsetRect(&frameData.bounds, -4, -4);
  771.         frameData.inactive = ((*theControl)->contrlHilite == kControlInactive);
  772.     } else {
  773.         frameData.roundFrame = false;
  774.         frameData.inactive = true;    /* Since we want to draw userItem outlines in gray */
  775.     }
  776.     frameData.erasingOld = false;
  777.  
  778.     if (gQuickDrawVersion >= gestalt8BitQD) {
  779.         GetForeColor(&foreColor);
  780.         if (frameData.roundFrame) {
  781.             (void)GetAuxCtl(theControl, &theAuxCtl);
  782.             frameData.frameColor = (*(*theAuxCtl)->acCTable)->ctTable[cFrameColor].rgb;
  783.         } else {
  784.             frameData.frameColor = foreColor;
  785.         }
  786.     }
  787.     if (gQuickDrawVersion >= gestalt32BitQD13 && theDialog->portBits.rowBytes & 0xC000) {
  788.         GetBackColor(&frameData.backColor);
  789.         DeviceLoop(theDialog->visRgn, (DeviceLoopDrawingProcPtr)GrayFrameDrawingProc,
  790.             (long)&frameData, 0);
  791.     } else {
  792.         GrayFrameDrawingProc((gQuickDrawVersion >= gestalt8BitQD), 0, nil, &frameData);
  793.     }
  794.     if (gQuickDrawVersion >= gestalt8BitQD) {
  795.         RGBForeColor(&foreColor);
  796.     }
  797. }
  798.  
  799. static pascal void GrayFrameDrawingProc(short depth, short deviceFlags, GDHandle targetDevice,
  800.      GrayFrameDataPtr frameData)
  801. {
  802.     RGBColor        outlineColor;
  803.     short        radius;
  804.     
  805.     PenNormal();
  806.  
  807.     if (frameData->erasingOld) {
  808.         PenPat(qd.white);
  809.     } else {
  810.         if (depth)
  811.             outlineColor = frameData->frameColor;
  812.         if (frameData->inactive)
  813.             if (targetDevice == nil || GetGray(targetDevice, &frameData->backColor, &outlineColor) == false)
  814.                 PenPat(qd.gray);
  815.         if (depth)
  816.             RGBForeColor(&outlineColor);
  817.     }
  818.     if (frameData->roundFrame) {
  819.         PenSize(3, 3);
  820.         if ((radius = ((frameData->bounds.bottom - frameData->bounds.top) >> 1)) < 16)
  821.             radius = 16;
  822.         FrameRoundRect(&frameData->bounds, radius, radius);
  823.     } else {
  824.         FrameRect(&frameData->bounds);
  825.     }
  826.  
  827.     SetPenState(&frameData->penState);
  828. }
  829.  
  830. /* This is just a sample error handler... that is totally lame! You really need to look
  831.    up the error messages in a string resource and stuff, not use string constants like
  832.    I've shown here! (Hey, this wasn't a demo app showing how to handle errors! :-) */
  833. void ErrorHandler(StringPtr errorString)
  834. {
  835.     short    itemHit;
  836.  
  837.     SetCursor(&qd.arrow);
  838.     SetDAFont(systemFont);
  839.     ParamText(errorString, nil, nil, nil);
  840.     itemHit = StopAlert(rErrorAlert, nil);
  841.     ExitToShell();
  842. }
  843.